home *** CD-ROM | disk | FTP | other *** search
DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) NNNNAAAAMMMMEEEE DDDDPPPPSSSSLLLLDDDDUUUU____DDDDeeeessssttttrrrrooooyyyy, DDDDPPPPSSSSLLLLDDDDUUUU____EEEExxxxttttrrrraaaaccccttttPPPPeeeerrrrmmmm, DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr, DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC, DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCLLLLiiiimmmmiiiitttt, DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCPPPPaaaatttthhhh, DDDDPPPPSSSSLLLLDDDDUUUU____OOOOrrrrddddeeeerrrriiiinnnngggg, DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss, DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssssZZZZ, DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee, DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM, DDDDPPPPSSSSLLLLDDDDUUUU____SSSSttttoooorrrraaaaggggeeee - Parallel sparse unsymmetric solver for linear systems of real equations SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS Fortran synopsis: SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____DDDDEEEESSSSTTTTRRRROOOOYYYY ((((_t_o_k_e_n)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____EEEEXXXXTTTTRRRRAAAACCCCTTTTPPPPEEEERRRRMMMM ((((_t_o_k_e_n,,,, _p_e_r_m)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _p_e_r_m(*) SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____FFFFAAAACCCCTTTTOOOORRRR ((((_t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s,,,, _i_n_d_i_c_e_s,,,, _v_a_l_u_e_s)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s(*), _i_n_d_i_c_e_s(*) DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _v_a_l_u_e_s(*) SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____FFFFAAAACCCCTTTTOOOORRRROOOOOOOOCCCC ((((_t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s,,,, _i_n_d_i_c_e_s,,,, _v_a_l_u_e_s)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s(*),,,, _i_n_d_i_c_e_s(*) DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _v_a_l_u_e_s(*) SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCLLLLIIIIMMMMIIIITTTT ((((_t_o_k_e_n,,,, _o_o_c_l_i_m_i_t)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _o_o_c_l_i_m_i_t SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCPPPPAAAATTTTHHHH ((((_t_o_k_e_n,,,, _o_o_c_p_a_t_h)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n CCCCHHHHAAAARRRRAAAACCCCTTTTEEEERRRR _o_o_c_p_a_t_h(*) SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____OOOORRRRDDDDEEEERRRRIIIINNNNGGGG ((((_t_o_k_e_n,,,, _m_e_t_h_o_d)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _m_e_t_h_o_d SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____PPPPRRRREEEEPPPPRRRROOOOCCCCEEEESSSSSSSS ((((_t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s,,,, _i_n_d_i_c_e_s,,,, _n_o_n__z_e_r_o_s,,,, _o_p_s)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s(*),,,, _i_n_d_i_c_e_s(*) IIIINNNNTTTTEEEEGGGGEEEERRRR****8888 _n_o_n__z_e_r_o_s DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _o_p_s SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____PPPPRRRREEEEPPPPRRRROOOOCCCCEEEESSSSSSSSZZZZ ((((_t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s,,,, _i_n_d_i_c_e_s,,,, _m_a_s_k,,,, _n_o_n__z_e_r_o_s,,,, _o_p_s)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _n,,,, _p_o_i_n_t_e_r_s(*),,,, _i_n_d_i_c_e_s(*),,,, _m_a_s_k(*) IIIINNNNTTTTEEEEGGGGEEEERRRR****8888 _n_o_n__z_e_r_o_s DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _o_p_s SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____SSSSOOOOLLLLVVVVEEEE ((((_t_o_k_e_n,,,, _x,,,, _b)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _x(*),,,, _b(*) PPPPaaaaggggeeee 1111 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) SSSSUUUUBBBBRRRROOOOUUUUTTTTIIIINNNNEEEE DDDDPPPPSSSSLLLLDDDDUUUU____SSSSOOOOLLLLVVVVEEEEMMMM ((((_t_o_k_e_n,,,, _X,,,, _l_d_x,,,, _B,,,, _l_d_b,,,, _n_r_h_s)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n,,,, _l_d_x,,,, _l_d_b,,,, _n_r_h_s DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN _X(*),,,, _B(*) DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN DDDDPPPPSSSSLLLLDDDDUUUU____SSSSTTTTOOOORRRRAAAAGGGGEEEE((((_t_o_k_e_n)))) IIIINNNNTTTTEEEEGGGGEEEERRRR _t_o_k_e_n C/C++ synopsis: ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>> vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____DDDDeeeessssttttrrrrooooyyyy ((((iiiinnnntttt _t_o_k_e_n))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____EEEExxxxttttrrrraaaaccccttttPPPPeeeerrrrmmmm ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _p_e_r_m[[[[]]]]))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _p_o_i_n_t_e_r_s[[[[]]]],,,, iiiinnnntttt _i_n_d_i_c_e_s[[[[]]]],,,, ddddoooouuuubbbblllleeee _v_a_l_u_e_s[[[[]]]]))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _p_o_i_n_t_e_r_s[[[[]]]],,,, iiiinnnntttt _i_n_d_i_c_e_s[[[[]]]],,,, ddddoooouuuubbbblllleeee _v_a_l_u_e_s[[[[]]]]))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCLLLLiiiimmmmiiiitttt ((((iiiinnnntttt _t_o_k_e_n,,,, ddddoooouuuubbbblllleeee _o_o_c_l_i_m_i_t))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCPPPPaaaatttthhhh ((((iiiinnnntttt _t_o_k_e_n,,,, cccchhhhaaaarrrr _o_o_c_p_a_t_h[[[[]]]]))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____OOOOrrrrddddeeeerrrriiiinnnngggg ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _m_e_t_h_o_d))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _p_o_i_n_t_e_r_s[[[[]]]],,,, iiiinnnntttt _i_n_d_i_c_e_s[[[[]]]],,,, lllloooonnnngggg lllloooonnnngggg *_n_o_n__z_e_r_o_s,,,, ddddoooouuuubbbblllleeee *_o_p_s))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssssZZZZ ((((iiiinnnntttt _t_o_k_e_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _p_o_i_n_t_e_r_s[[[[]]]],,,, iiiinnnntttt _i_n_d_i_c_e_s[[[[]]]],,,, iiiinnnntttt _m_a_s_k[[[[]]]],,,, lllloooonnnngggg lllloooonnnngggg *_n_o_n__z_e_r_o_s,,,, ddddoooouuuubbbblllleeee *_o_p_s))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee ((((iiiinnnntttt _t_o_k_e_n,,,, ddddoooouuuubbbblllleeee _x[[[[]]]],,,, ddddoooouuuubbbblllleeee _b[[[[]]]]))));;;; vvvvooooiiiidddd DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM ((((iiiinnnntttt _t_o_k_e_n,,,, ddddoooouuuubbbblllleeee _X[[[[]]]],,,, iiiinnnntttt _l_d_x,,,, ddddoooouuuubbbblllleeee _B[[[[]]]],,,, iiiinnnntttt _l_d_b,,,, iiiinnnntttt _n_r_h_s))));;;; ddddoooouuuubbbblllleeee DDDDPPPPSSSSLLLLDDDDUUUU____SSSSttttoooorrrraaaaggggeeee ((((iiiinnnntttt _t_o_k_e_n))));;;; IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN These routines are part of the SCSL Scientific Library and can be loaded using either the ----llllssssccccssss or the ----llllssssccccssss____mmmmpppp option. The ----llllssssccccssss____mmmmpppp option directs the linker to use the multi-processor version of the library. When linking to SCSL with ----llllssssccccssss or ----llllssssccccssss____mmmmpppp, the default integer size is 4 bytes (32 bits). Another version of SCSL is available in which integers are 8 bytes (64 bits). This version allows the user access to larger memory sizes and helps when porting legacy Cray codes. It can be loaded by using the ----llllssssccccssss____iiii8888 option or the ----llllssssccccssss____iiii8888____mmmmpppp option. A program may use only one of the two versions; 4-byte integer and 8-byte integer library calls cannot be mixed. PPPPaaaaggggeeee 2222 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) The C and C++ prototypes shown above are appropriate for the 4-byte integer version of SCSL. When using the 8-byte integer version, the variables of type iiiinnnntttt become lllloooonnnngggg lllloooonnnngggg and the <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>> header file should be included. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN DDDDPPPPSSSSLLLLDDDDUUUU solves sparse unsymmetric linear systems of the form _A_x = _b where _A is a real _n-by-_n input matrix having symmetric non-zero pattern but unsymmetric non-zero values, _b is a real input vector of length _n, and _x is an unknown real vector of length _n. DDDDPPPPSSSSLLLLDDDDUUUU uses a direct method. _A is factored into the following form: _A = _L _D _U where _L is a lower triangular matrix with unit diagonal, _D is a diagonal matrix, and UUUU is an upper triangular matrix with unit diagonal. Note that NO PIVOTING FOR STABILITY is performed during factorization. The DDDDPPPPSSSSLLLLDDDDUUUU library contains five main routines. * DDDDPPPPSSSSLLLLDDDDUUUU____OOOOrrrrddddeeeerrrriiiinnnngggg(((()))) allows the user to select one of five possible reordering methods to be used in the matrix preprocessing phase. * DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss(((()))) performs preprocessing operations on the structure of _A (heuristic reordering to reduce fill in _L and _U, symbolic factorization, etc.). * DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) factors the matrix _A into _L and _U, using the previously computed preprocessing data. * DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) solves for a vector _x, given an input vector _b. * DDDDPPPPSSSSLLLLDDDDUUUU____DDDDeeeessssttttrrrrooooyyyy(((()))) frees all storage associated with the matrix _A (including _L, _D, _U, and various data structures computed during preprocessing). The user can call DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) several times after a single call to DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss(((()))) to factor multiple matrices with identical non-zero structures but different values. Similarly, the user can call DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) several times after a single call to DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) to solve for multiple right-hand-sides. Also, the user can call DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) to solve for multiple right-hand-sides all stored in a single array. SSSSppppaaaarrrrsssseeee MMMMaaaattttrrrriiiixxxx FFFFoooorrrrmmmmaaaatttt Sparse matrix _A must be input to DDDDPPPPSSSSLLLLDDDDUUUU in Harwell-Boeing format (also known as Compressed Column Storage format). PPPPaaaaggggeeee 3333 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) The matrix is held in three arrays: _p_o_i_n_t_e_r_s, _i_n_d_i_c_e_s, and _v_a_l_u_e_s. The _i_n_d_i_c_e_s array contains the row indices of the non-zeros in _A. The _v_a_l_u_e_s array holds the corresponding non-zero values. The _p_o_i_n_t_e_r_s array contains the index in _i_n_d_i_c_e_s for the first non-zero in each column of _A. Thus, the row indices for the non-zeros in column _i can be found in locations _i_n_d_i_c_e_s[[[[_p_o_i_n_t_e_r_s[[[[_i]]]]]]]] through _i_n_d_i_c_e_s[[[[_p_o_i_n_t_e_r_s[[[[_i+1]]]]-1]]]]. The corresponding values can be found in location _v_a_l_u_e_s[[[[_p_o_i_n_t_e_r_s[[[[_i]]]]]]]] through _v_a_l_u_e_s[[[[_p_o_i_n_t_e_r_s[[[[_i+1]]]]-1]]]]. DDDDPPPPSSSSLLLLDDDDUUUU imposes one constraint on the representation of the _A matrix. The non-zeros within each column must appear in order of increasing row number. In the following example, the unsymmetric matrix 1.0 0.0 5.0 0.0 0.0 3.0 0.0 8.0 2.0 0.0 7.0 0.0 0.0 4.0 0.0 9.0 would be represented in FORTRAN as follows: INTEGER pointers(5), indices(8), i DOUBLE PRECISION values(8) DATA (pointers(i), i = 1, 5) / 1, 3, 5, 7, 9 / DATA (indices(i), i = 1, 8) / 1, 3, 2, 4, 1, 3, 2, 4 / DATA (values(i), i = 1, 8) / 1.0, 2.0, 3.0, 4.0, 5.0, & 7.0, 8.0, 9.0 / Zero-based indexing is used in C, so the pointers, indices, and values arrays would contain the following: int pointers[] = {0, 2, 4, 6, 8}; int indices[] = {0, 2, 1, 3, 0, 2, 1, 3}; double values[] = {1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 8.0, 9.0}; OOOOrrrrddddeeeerrrriiiinnnngggg MMMMeeeetttthhhhooooddddssss The DDDDPPPPSSSSLLLLDDDDUUUU____OOOOrrrrddddeeeerrrriiiinnnngggg((((_t_o_k_e_n,,,, _m_e_t_h_o_d)))) routine allows the user to change the ordering method used to pre-order the matrix before factorization. This routine must be called before calling DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss(((()))). Five options are currently available for the method parameter: * Method 0 performs no pre-ordering * Method 1 performs Approximate Minimum Fill ordering * Method 2 performs a single nested dissection ordering (default). This method is often called "Extreme matrix ordering". PPPPaaaaggggeeee 4444 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) * Method 3 performs multiple nested dissection orderings (in parallel) * Method 4 performs multiple nested dissection (the same as in Method 3), but it uses a feedback file to "learn" from the previous solves of the same matrix structure and it performs more orderings. The multiple nested dissection technique of Methods 3 and 4 is also referred to as "Extreme2 matrix ordering". Method 2 is significantly more expensive than Method 1, but it usually produces significantly better orderings. Method 3 is especially effective on multi-processor systems. It computes OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS (where OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS is an environment variable indicating the number of processors to be used for parallel computation) matrix orderings using different starting points for the algorithm and uses the ordering that will lead to the fewest floating-point operations to factorize the matrix. Method 4 is useful only when the same non-zero structure is used for multiple solves. Method 4 keeps a record in a "feedback" file of a signature for non-zero structures for a maximum of 200 matrices and of the starting point that was saved from a previous solve for that structure. In the next Method 4 ordering for that non-zero structure, that best starting point and 2222 **** OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS ---- 1111 new ones generate orderings. The best ordering is used. In this way, the quality of orderings stay the same or improve over time. Methods 3 and 4 typically take more time for the matrix preprocessing than the default. However, on large systems or on repeated factorizations, significant overall speedups (1.1X to 2X) can be obtained compared to Method 2. EEEExxxxttttrrrraaaaccccttttiiiinnnngggg tttthhhheeee ppppeeeerrrrmmmmuuuuttttaaaattttiiiioooonnnn vvvveeeeccccttttoooorrrr Unless ordering Method 0 is used, DDDDPPPPSSSSLLLLDDDDUUUU applies a symmetric permutation to matrix A before the factorization step; the resulting permuted matrix generally has significantly less fill-in than the original matrix. The user can obtain the permutation matrix associated with a given token by calling DDDDPPPPSSSSLLLLDDDDUUUU____EEEExxxxttttrrrraaaaccccttttPPPPeeeerrrrmmmm((((_t_o_k_e_n,,,, _p_e_r_m)))). The permutation is returned as an integer array of length _n, with 1111 <<<<==== ppppeeeerrrrmmmm((((iiii)))) <<<<==== nnnn (0000 <<<<==== ppppeeeerrrrmmmm[[[[iiii]]]] <<<< nnnn for C code). A value of _k for _p_e_r_m(_i) implies that node _k in the original ordering is node _i in the new ordering. MMMMaaaattttrrrriiiicccceeeessss wwwwiiiitttthhhh zzzzeeeerrrroooossss oooonnnn tttthhhheeee ddddiiiiaaaaggggoooonnnnaaaallll As noted above, no pivoting is done for stability during factorization; when zero or near-zero pivots are encountered, DDDDPPPPSSSSLLLLDDDDUUUU usually fails. In these cases, it may be possible to use DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssssZZZZ(((()))) to obtain a slightly different, but stable, ordering. The user provides an additional integer array, _m_a_s_k, as an argument to DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssssZZZZ(((()))). If _m_a_s_k(_i)====0000, then DDDDPPPPSSSSLLLLDDDDUUUU will attempt to maximize the diagonal element ||||AAAAiiiiiiii||||. PPPPaaaaggggeeee 5555 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) MMMMeeeemmmmoooorrrryyyy uuuussssaaaaggggeeee The returned value of DDDDPPPPSSSSLLLLDDDDUUUU____SSSSttttoooorrrraaaaggggeeee(((()))) is an estimate of the amount of storage required (in millions of bytes) by the solver's data structures for a given matrix system. OOOOuuuutttt----ooooffff----ccccoooorrrreeee FFFFaaaaccccttttoooorrrriiiizzzzaaaattttiiiioooonnnn The storage associated with the factor can be managed in two ways. The DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) routine allocates memory for the factor and manages it internally, releasing it only when DDDDPPPPSSSSLLLLDDDDUUUU____DDDDeeeessssttttrrrrooooyyyy(((()))) is called. The alternative is to do out-of-core factorization by calling DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC(((()))). This routine uses a small amount of in-core memory, placing the remainder of the factor matrix on disk as it is computed. The user can call DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCPPPPaaaatttthhhh(((()))) to indicate the directory in which the factor file should be written, and DDDDPPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCLLLLiiiimmmmiiiitttt(((()))) to indicate how much memory to use to hold portions of the factor matrix in-core. More in- core memory generally leads to less disk I/O and higher performance during the factorization. The only required change is to move from in- core factorization to out-of-core factorization is the change from DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) to DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC(((()))). The other routines (DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))), DDDDPPPPSSSSLLLLDDDDUUUU____DDDDeeeessssttttrrrrooooyyyy(((()))), etc.) handle out-of-core factors transparently. Note that DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC(((()))) and subsequent calls to DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) are not parallelized (but calls to DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) are parallelized, as discussed below). MMMMuuuullllttttiiiipppplllleeee RRRRiiiigggghhhhtttt----HHHHaaaannnndddd----SSSSiiiiddddeeeessss DDDDPPPPSSSSLLLLDDDDUUUU can solve for large numbers of right-hand-sides with one call to DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))). It solves these right hand sides in parallel, with each processor solving up to four at a time for in-core systems and up to PPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCBBBBLLLLKKKK at a time for out-of-core systems, where PPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCBBBBLLLLKKKK is an environment variable whose default value is 1. IIIInnnn----ppppllllaaaacccceeee SSSSoooollllvvvveeeessss Both DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) and DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) allow the solution vector(s) to overwrite the right-hand-side(s) when identical vectors or matrices are supplied to these routines. For example, CALL DPSLDU_SOLVE(token, b, b) takes the right-hand-side input from _b and also returns the solution vector in _b. When this option is used with DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))), the leading dimensions for the solution and right-hand-side matrices must agree. The amount of memory actually saved by performing an in-place solve depends on the number of right-hand-sides used. For a single right-hand-side, there are no net savings versus an out-of-place solve because a temporary copy of the input vector is made internally. For multiple right-hand- sides the memory overhead decreases as the ratio of right-hand-sides to processors used increases. AAAArrrrgggguuuummmmeeeennnnttttssss These routines have the following arguments: PPPPaaaaggggeeee 6666 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) _t_o_k_e_n (input) DDDDPPPPSSSSLLLLDDDDUUUU can handle multiple matrices simultaneously. The _t_o_k_e_n distinguishes between active matrices. The _t_o_k_e_n passed to DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))) must match the _t_o_k_e_n used in some previous call to DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssss(((()))). Similarly, the _t_o_k_e_n passed to DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) must match the _t_o_k_e_n used in some previous call to DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrr(((()))). 0000 <<<<==== _t_o_k_e_n <<<<==== 11119999.... _m_e_t_h_o_d (input) An integer specifying the ordering method used during preprocessing. 0000 <<<<==== _m_e_t_h_o_d <<<<==== 4444.... _n (input) The number of rows and columns in the matrix _A. _n >>>>==== 0000.... _p_o_i_n_t_e_r_s, _i_n_d_i_c_e_s, _v_a_l_u_e_s (input) The _p_o_i_n_t_e_r_s and _i_n_d_i_c_e_s arrays store the non-zero structure of sparse input matrix _A in Harwell-Boeing or Compressed Sparse Column (CSC) format. The _p_o_i_n_t_e_r_s array stores _n+1 integers, where _p_o_i_n_t_e_r_s[[[[_i]]]] gives the index in _i_n_d_i_c_e_s of the first non-zero in column _i of _A. The _i_n_d_i_c_e_s array stores the row indices of the non-zeros in _A. The _v_a_l_u_e_s array stores the non-zero values in the matrix _A. _n_o_n__z_e_r_o_s (output) The number of non-zero values in _L and _U. _o_p_s (output) The number of floating-point operations required to factor _A. _m_a_s_k (input) An integer array of length _n used in DDDDPPPPSSSSLLLLDDDDUUUU____PPPPrrrreeeepppprrrroooocccceeeessssssssZZZZ(((()))). If _m_a_s_k(_i) ==== 0000, then node _i of matrix A is ordered after all of its neighbors in an attempt to avoid a zero pivot. _b (input) The right-hand-side vector in a DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) call. _x (output) The solution vector in a DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeee(((()))) call. _n_r_h_s (input) The number of right-hand side vectors present in a DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) call. _B (input) The right-hand-side matrix in a DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) call. Must be stored in column-major order. _l_d_b (input) The leading dimension of matrix _B. _l_d_b >>>>==== _n. _X (output) The solution matrix in a DDDDPPPPSSSSLLLLDDDDUUUU____SSSSoooollllvvvveeeeMMMM(((()))) call. Must be stored in column-major order. _l_d_x (input) The leading dimension of matrix _X. _l_d_x >>>>==== _n. PPPPaaaaggggeeee 7777 DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) DDDDPPPPSSSSLLLLDDDDUUUU((((3333SSSS)))) _o_o_c_p_a_t_h (input) A character array/string with a path to the directory where the temporary out-of-core factor files should be stored. If this path is on a striped (or raid-0) file system, the performance of the out-of-core solves can be considerably improved. The default path is ////uuuussssrrrr////ttttmmmmpppp. _o_o_c_l_i_m_i_t (input) A double precision number indicating the number of Mbytes of random access memory that should be used for factor storage during a call to DDDDPPPPSSSSLLLLDDDDUUUU____FFFFaaaaccccttttoooorrrrOOOOOOOOCCCC(((()))). Note that there are many other arrays used besides those directly used to store the factorization, so total RAM usage by the solve will exceed this number. The default is 64 MB. _p_e_r_m (output) An integer array of length _n containing the permutation used to reorder matrix A. EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS Two environment variables can affect the operation of ordering methods 3 and 4. SSSSPPPPAAAARRRRSSSSEEEE____NNNNUUUUMMMM____OOOORRRRDDDDEEEERRRRSSSS can be used to change the number of orderings performed from the default of OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS for Method 3 and (2*OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS) for Method 4. SSSSPPPPAAAARRRRSSSSEEEE____FFFFEEEEEEEEDDDDBBBBAAAACCCCKKKK____FFFFIIIILLLLEEEE can be set to the path and file name where the feedback information will be kept; otherwise, the default feedback file is $$$$HHHHOOOOMMMMEEEE////....ssssppppaaaarrrrsssseeeeFFFFeeeeeeeeddddbbbbaaaacccckkkk. This file will be less than 5K bytes. The environment variable OOOOMMMMPPPP____NNNNUUUUMMMM____TTTTHHHHRRRREEEEAAAADDDDSSSS determines the number of processors that are used for the numerical factorization and solve phases. Out-of-core solves can be performed in groups of PPPPSSSSLLLLDDDDUUUU____OOOOOOOOCCCCBBBBLLLLKKKK right-hand-sides per processor. Setting the environment variable PPPPSSSSLLLLDDDDUUUU____VVVVEEEERRRRBBBBOOOOSSSSEEEE causes DDDDPPPPSSSSLLLLDDDDUUUU to output information about the factorization. NNNNOOOOTTTTEEEESSSS These routines are optimized and parallelized for the SGI R8000 and R1x000 platforms. SSSSEEEEEEEE AAAALLLLSSSSOOOO IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S), IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS(3S), DDDDPPPPSSSSLLLLDDDDLLLLTTTT(3S), ZZZZPPPPSSSSLLLLDDDDLLLLTTTT(3S), ZZZZPPPPSSSSLLLLDDDDUUUU(3S) PPPPaaaaggggeeee 8888 
